home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / CodeFragments.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  8.3 KB  |  311 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        CodeFragments.p
  3.  
  4.      Contains:    Code Fragment Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT CodeFragments;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __CODEFRAGMENTS__}
  30. {$SETC __CODEFRAGMENTS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC CodeFragmentsIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __FILES__}
  43. {$I Files.p}
  44. {$ENDC}
  45. {    MixedMode.p                                                    }
  46. {    OSUtils.p                                                    }
  47. {        Memory.p                                                }
  48. {    Finder.p                                                    }
  49.  
  50. {$PUSH}
  51. {$ALIGN MAC68K}
  52. {$LibExport+}
  53.  
  54. CONST
  55.     kCFragResourceType            = 'cfrg';
  56.     kCFragResourceID            = 0;
  57.     kCFragLibraryFileType        = 'shlb';
  58.  
  59.     
  60. TYPE
  61.     CFragArchitecture = OSType;
  62.  
  63.  
  64. CONST
  65.     kPowerPCCFragArch            = 'pwpc';
  66.     kMotorola68KCFragArch        = 'm68k';
  67.     kAnyCFragArch                = $3F3F3F3F;
  68.  
  69. {$IFC GENERATINGPOWERPC }
  70.     kCurrentCFragArch            = kPowerPCCFragArch;
  71.  
  72. {$ENDC}
  73. {$IFC GENERATING68K }
  74.     kCurrentCFragArch            = kMotorola68KCFragArch;
  75.  
  76. {$ENDC}
  77.     
  78. TYPE
  79.     CFragConnectionID = UInt32;
  80.  
  81.     CFragClosureID = UInt32;
  82.  
  83.     CFragContextID = UInt32;
  84.  
  85.     CFragContainerID = UInt32;
  86.  
  87.     
  88. TYPE
  89.     CFragLoadOptions = UInt32;
  90.  
  91.  
  92. CONST
  93.     kLoadCFrag                    = $01;                            { Try to use existing copy, load if not found.}
  94.     kFindCFrag                    = $02;                            { Try find an existing copy, don't load if not found.}
  95.     kNewCFragCopy                = $05;                            { Load a new copy whether one already exists or not.}
  96.     kInplaceCFrag                = $80;                            { Use data sections directly in the container.}
  97.  
  98.     kUnresolvedCFragSymbolAddress = 0;
  99.  
  100.     
  101. TYPE
  102.     CFragSymbolClass = UInt8;
  103.  
  104.  
  105. CONST
  106.     kCodeCFragSymbol            = 0;
  107.     kDataCFragSymbol            = 1;
  108.     kTVectorCFragSymbol            = 2;
  109.     kTOCCFragSymbol                = 3;
  110.     kGlueCFragSymbol            = 4;
  111.  
  112.     
  113. TYPE
  114.     CFragUsage = UInt8;
  115.  
  116.  
  117. CONST
  118.     kImportLibraryCFrag            = 0;                            { Standard CFM import library.}
  119.     kApplicationCFrag            = 1;                            { Macintosh application.}
  120.     kDropInAdditionCFrag        = 2;                            { Private extension to an application or library.}
  121.  
  122.     kIsCompleteCFrag            = 0;                            { A "base" fragment, not an update.}
  123.     kFirstCFragUpdate            = 1;                            { The first update, others are numbered 2, 3, ...}
  124.  
  125.     
  126. TYPE
  127.     CFragLocatorKind = UInt8;
  128.  
  129.  
  130. CONST
  131.     kMemoryCFragLocator            = 0;                            { Container is already addressable.}
  132.     kDataForkCFragLocator        = 1;                            { Container is in a file's data fork.}
  133.     kResourceCFragLocator        = 2;                            { Container is in a file's resource fork.}
  134.     kByteStreamCFragLocator        = 3;                            { Container is in a given file fork as a byte stream.}
  135.  
  136.     kCFragGoesToEOF                = 0;
  137.  
  138.  
  139. TYPE
  140.     CFragOldMemoryLocator = PACKED RECORD
  141.         address:                LogicalAddress;
  142.         length:                    UInt32;
  143.         inPlace:                BOOLEAN;
  144.         reserved3a:                ARRAY [0..2] OF UInt8;                    { ! Do not use this!}
  145.     END;
  146.  
  147.     CFragHFSDiskFlatLocator = RECORD
  148.         fileSpec:                FSSpecPtr;
  149.         offset:                    UInt32;
  150.         length:                    UInt32;
  151.     END;
  152.  
  153. { ! This must have a file specification at the same offset as a data fork locator!}
  154.     CFragHFSSegmentedLocator = PACKED RECORD
  155.         fileSpec:                FSSpecPtr;
  156.         rsrcType:                OSType;
  157.         rsrcID:                    SInt16;
  158.         reserved2a:                UInt16;                                    { ! Do not use this!}
  159.     END;
  160.  
  161.     CFragHFSLocator = RECORD
  162.         where:                    SInt32;                                    { Really of type CFragLocatorKind.}
  163.         CASE INTEGER OF
  164.         0: (
  165.             onDisk:                        CFragHFSDiskFlatLocator;            { First so debugger shows this form.}
  166.            );
  167.         1: (
  168.             inMem:                        CFragOldMemoryLocator;
  169.            );
  170.         2: (
  171.             inSegs:                        CFragHFSSegmentedLocator;
  172.            );
  173.     END;
  174.  
  175.     CFragHFSLocatorPtr = ^CFragHFSLocator;
  176.  
  177. { -------------------------------------------------------------------------------------------}
  178. { The parameter block passed to fragment initialization functions.  The locator and name}
  179. { pointers are valid only for the duration of the initialization routine.  I.e. if you want}
  180. { to save the locator or name, save the contents, not the pointers.  Initialization routines}
  181. { take one parameter, a pointer to the parameter block, and return a success/failure result.}
  182. { ! Note that the initialization function returns an OSErr.  Any result other than noErr will}
  183. { ! cause the entire load to be aborted at that point.}
  184.     CFragInitBlock = RECORD
  185.         contextID:                CFragContextID;
  186.         closureID:                CFragClosureID;
  187.         connectionID:            CFragConnectionID;
  188.         fragLocator:            CFragHFSLocator;
  189.         libName:                StringPtr;
  190.         reserved4a:                UInt32;                                    { ! Do not use this!}
  191.         reserved4b:                UInt32;                                    { ! Do not use this!}
  192.         reserved4c:                UInt32;                                    { ! Do not use this!}
  193.         reserved4d:                UInt32;                                    { ! Do not use this!}
  194.     END;
  195.  
  196.     CFragInitBlockPtr = ^CFragInitBlock;
  197.  
  198.     CFragInitFunction = ProcPtr;  { FUNCTION ((CONST)VAR theInitBlock: CFragInitBlock): OSErr; }
  199.  
  200.     CFragTermRoutine = ProcPtr;  { PROCEDURE ; }
  201.  
  202.     CFragInitFunctionPtr = ^CFragInitFunction;
  203.  
  204.     CFragTermRoutinePtr = ^CFragTermRoutine;
  205.  
  206. { §}
  207. { ===========================================================================================}
  208. { Routines}
  209. { ========}
  210.  
  211. FUNCTION GetSharedLibrary(libName: ConstStr63Param; archType: OSType; loadFlags: CFragLoadOptions; VAR connID: CFragConnectionID; VAR mainAddr: Ptr; VAR errMessage: Str255): OSErr;
  212.     {$IFC NOT GENERATINGCFM}
  213.     INLINE $3F3C, $0001, $AA5A;
  214.     {$ENDC}
  215. FUNCTION GetDiskFragment({CONST}VAR fileSpec: FSSpec; offset: UInt32; length: UInt32; fragName: ConstStr63Param; loadFlags: CFragLoadOptions; VAR connID: CFragConnectionID; VAR mainAddr: Ptr; VAR errMessage: Str255): OSErr;
  216.     {$IFC NOT GENERATINGCFM}
  217.     INLINE $3F3C, $0002, $AA5A;
  218.     {$ENDC}
  219. FUNCTION GetMemFragment(memAddr: UNIV Ptr; length: UInt32; fragName: ConstStr63Param; loadFlags: CFragLoadOptions; VAR connID: CFragConnectionID; VAR mainAddr: Ptr; VAR errMessage: Str255): OSErr;
  220.     {$IFC NOT GENERATINGCFM}
  221.     INLINE $3F3C, $0003, $AA5A;
  222.     {$ENDC}
  223. FUNCTION CloseConnection(VAR connID: CFragConnectionID): OSErr;
  224.     {$IFC NOT GENERATINGCFM}
  225.     INLINE $3F3C, $0004, $AA5A;
  226.     {$ENDC}
  227. FUNCTION FindSymbol(connID: CFragConnectionID; symName: ConstStr255Param; VAR symAddr: Ptr; VAR symClass: CFragSymbolClass): OSErr;
  228.     {$IFC NOT GENERATINGCFM}
  229.     INLINE $3F3C, $0005, $AA5A;
  230.     {$ENDC}
  231. FUNCTION CountSymbols(connID: CFragConnectionID; VAR symCount: LONGINT): OSErr;
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $3F3C, $0006, $AA5A;
  234.     {$ENDC}
  235. FUNCTION GetIndSymbol(connID: CFragConnectionID; symIndex: LONGINT; VAR symName: Str255; VAR symAddr: Ptr; VAR symClass: CFragSymbolClass): OSErr;
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $3F3C, $0007, $AA5A;
  238.     {$ENDC}
  239. {$IFC OLDROUTINENAMES }
  240.     
  241. TYPE
  242.     ConnectionID = CFragConnectionID;
  243.  
  244.     LoadFlags = CFragLoadOptions;
  245.  
  246.     SymClass = CFragSymbolClass;
  247.  
  248.     MemFragment = CFragOldMemoryLocator;
  249.  
  250.     DiskFragment = CFragHFSDiskFlatLocator;
  251.  
  252.     SegmentedFragment = CFragHFSSegmentedLocator;
  253.  
  254.     FragmentLocator = CFragHFSLocator;
  255.  
  256.     FragmentLocatorPtr = CFragHFSLocatorPtr;
  257.  
  258.     InitBlock = CFragInitBlock;
  259.  
  260.     InitBlockPtr = CFragInitBlockPtr;
  261.  
  262.     ConnectionInitializationRoutine = CFragInitFunction;
  263.  
  264.     ConnectionTerminationRoutine = CFragTermRoutine;
  265.  
  266.  
  267. CONST
  268.     kPowerPCArch                = kPowerPCCFragArch;
  269.     kMotorola68KArch            = kMotorola68KCFragArch;
  270.     kAnyArchType                = kAnyCFragArch;
  271.     kNoLibName                    = 0;
  272.     kNoConnectionID                = 0;
  273.     kLoadLib                    = kLoadCFrag;
  274.     kFindLib                    = kFindCFrag;
  275.     kLoadNewCopy                = kNewCFragCopy;
  276.     kUseInPlace                    = kInplaceCFrag;
  277.     kCodeSym                    = kCodeCFragSymbol;
  278.     kDataSym                    = kDataCFragSymbol;
  279.     kTVectSym                    = kTVectorCFragSymbol;
  280.     kTOCSym                        = kTOCCFragSymbol;
  281.     kGlueSym                    = kGlueCFragSymbol;
  282.     kInMem                        = kMemoryCFragLocator;
  283.     kOnDiskFlat                    = kDataForkCFragLocator;
  284.     kOnDiskSegmented            = kResourceCFragLocator;
  285.     kIsLib                        = kImportLibraryCFrag;
  286.     kIsApp                        = kApplicationCFrag;
  287.     kIsDropIn                    = kDropInAdditionCFrag;
  288.     kFullLib                    = kIsCompleteCFrag;
  289.     kUpdateLib                    = kFirstCFragUpdate;
  290.     kWholeFork                    = kCFragGoesToEOF;
  291.     kCFMRsrcType                = kCFragResourceType;
  292.     kCFMRsrcID                    = kCFragResourceID;
  293.     kSHLBFileType                = kCFragLibraryFileType;
  294.     kUnresolvedSymbolAddress    = kUnresolvedCFragSymbolAddress;
  295.  
  296.     kPowerPC                    = kPowerPCCFragArch;
  297.     kMotorola68K                = kMotorola68KCFragArch;
  298.  
  299. {$ENDC}
  300.  
  301. {$ALIGN RESET}
  302. {$POP}
  303.  
  304. {$SETC UsingIncludes := CodeFragmentsIncludes}
  305.  
  306. {$ENDC} {__CODEFRAGMENTS__}
  307.  
  308. {$IFC NOT UsingIncludes}
  309.  END.
  310. {$ENDC}
  311.